{{>licenseInfo}}
#ifndef {{prefix}}_HELPERS_H
#define {{prefix}}_HELPERS_H

#include <QJsonObject>
#include <QJsonValue>
#include <QJsonArray>
#include <QList>
#include <QMap>
#include <QDateTime>
#include <QByteArray>
#include <QDate>
#include <QVariant>

#include "{{prefix}}Object.h"
#include "{{prefix}}Enum.h"
#include "{{prefix}}HttpFileElement.h"

{{#cppNamespaceDeclarations}}
namespace {{this}} {
{{/cppNamespaceDeclarations}}

    QString toStringValue(const QString &value);
    QString toStringValue(const QDateTime &value);
    QString toStringValue(const QByteArray &value);
    QString toStringValue(const QDate &value);
    QString toStringValue(const qint32 &value);
    QString toStringValue(const qint64 &value);
    QString toStringValue(const bool &value);
    QString toStringValue(const float &value);
    QString toStringValue(const double &value);
    QString toStringValue(const {{prefix}}Object &value);
    QString toStringValue(const {{prefix}}Enum &value);    
    QString toStringValue(const {{prefix}}HttpFileElement &value);    

    template <typename T>
    QString toStringValue(const QList<T> &val) {
        QString strArray;
        for(const auto& item : val) {
            strArray.append(toStringValue(item) + ",");
        }
        if(val.count() > 0) {
            strArray.chop(1);
        }
        return strArray;
    }

    QJsonValue toJsonValue(const QString &value);
    QJsonValue toJsonValue(const QDateTime &value);
    QJsonValue toJsonValue(const QByteArray &value);
    QJsonValue toJsonValue(const QDate &value);
    QJsonValue toJsonValue(const qint32 &value);
    QJsonValue toJsonValue(const qint64 &value);
    QJsonValue toJsonValue(const bool &value);
    QJsonValue toJsonValue(const float &value);
    QJsonValue toJsonValue(const double &value);
    QJsonValue toJsonValue(const {{prefix}}Object &value);
    QJsonValue toJsonValue(const {{prefix}}Enum &value);
    QJsonValue toJsonValue(const {{prefix}}HttpFileElement &value);    

    template <typename T>
    QJsonValue toJsonValue(const QList<T> &val) {
        QJsonArray jArray;
        for(const auto& item : val) {
            jArray.append(toJsonValue(item));
        }
        return jArray;
    }

    template <typename T>
    QJsonValue toJsonValue(const QMap<QString, T> &val) {
        QJsonObject jObject;
        for(const auto& itemkey : val.keys()) {
            jObject.insert(itemkey, toJsonValue(val.value(itemkey)));
        }
        return jObject;
    }

    bool fromStringValue(const QString &inStr, QString &value);
    bool fromStringValue(const QString &inStr, QDateTime &value);
    bool fromStringValue(const QString &inStr, QByteArray &value);
    bool fromStringValue(const QString &inStr, QDate &value);
    bool fromStringValue(const QString &inStr, qint32 &value);
    bool fromStringValue(const QString &inStr, qint64 &value);
    bool fromStringValue(const QString &inStr, bool &value);
    bool fromStringValue(const QString &inStr, float &value);
    bool fromStringValue(const QString &inStr, double &value);
    bool fromStringValue(const QString &inStr, {{prefix}}Object &value);
    bool fromStringValue(const QString &inStr, {{prefix}}Enum &value);    
    bool fromStringValue(const QString &inStr, {{prefix}}HttpFileElement &value);    

    template <typename T>
    bool fromStringValue(const QList<QString> &inStr, QList<T> &val) {
        bool ok = (inStr.count() > 0);
        for(const auto& item: inStr){
            T itemVal;
            ok &= fromStringValue(item, itemVal);
            val.push_back(itemVal);
        }
        return ok;
    }

    template <typename T>
    bool fromStringValue(const QMap<QString, QString> &inStr, QMap<QString, T> &val) {
        bool ok = (inStr.count() > 0);
        for(const auto& itemkey : inStr.keys()){
            T itemVal;
            ok &= fromStringValue(inStr.value(itemkey), itemVal);
            val.insert(itemkey, itemVal);
        }
        return ok;
    }

    bool fromJsonValue(QString &value, const QJsonValue &jval);
    bool fromJsonValue(QDateTime &value, const QJsonValue &jval);
    bool fromJsonValue(QByteArray &value, const QJsonValue &jval);
    bool fromJsonValue(QDate &value, const QJsonValue &jval);
    bool fromJsonValue(qint32 &value, const QJsonValue &jval);
    bool fromJsonValue(qint64 &value, const QJsonValue &jval);
    bool fromJsonValue(bool &value, const QJsonValue &jval);
    bool fromJsonValue(float &value, const QJsonValue &jval);
    bool fromJsonValue(double &value, const QJsonValue &jval);
    bool fromJsonValue({{prefix}}Object &value, const QJsonValue &jval);
    bool fromJsonValue({{prefix}}Enum &value, const QJsonValue &jval);
    bool fromJsonValue({{prefix}}HttpFileElement &value, const QJsonValue &jval);    

    template <typename T>
    bool fromJsonValue(QList<T> &val, const QJsonValue &jval) {
        bool ok = true;
        if(jval.isArray()){
            for(const auto& jitem : jval.toArray()){
                T item;
                ok &= fromJsonValue(item, jitem);
                val.push_back(item);
            }
        } else {
            ok = false;
        }
        return ok;
    }

    template <typename T>
    bool fromJsonValue(QMap<QString, T> &val, const QJsonValue &jval) {
        bool ok = true;
        if(jval.isObject()){
            auto varmap = jval.toObject().toVariantMap();
            if(varmap.count() > 0){
                for(const auto& itemkey : varmap.keys() ){
                    T itemVal;
                    ok &= fromJsonValue(itemVal, QJsonValue::fromVariant(varmap.value(itemkey)));
                    val.insert(itemkey, itemVal);
                }
            }
        } else {
            ok = false;
        }
        return ok;
    }

{{#cppNamespaceDeclarations}}
}
{{/cppNamespaceDeclarations}}

#endif // {{prefix}}_HELPERS_H
